---
title: 语法对比基础
---

# 语法对比基础

本模块深入探讨 JavaScript 和 C++ 之间基本语法差异，涵盖变量声明、控制流程、函数和基本数据类型。

## 变量声明和类型系统

JavaScript 是动态类型语言，这意味着变量类型在运行时确定。C++ 是静态类型语言，需要在编译时进行明确的类型声明。

<UniversalEditor title="变量声明和赋值对比" compare={true}>
```javascript !! js
// JavaScript: 动态类型
let age = 30; // 数字
let name = "Alice"; // 字符串
let isActive = true; // 布尔值

console.log(typeof age); // "number"
console.log(typeof name); // "string"
```

```cpp !! cpp
// C++: 静态类型
int age = 30; // 整数
std::string name = "Alice"; // 字符串
bool isActive = true; // 布尔值

// C++ 类型在编译时检查，没有类似 'typeof' 的运行时类型检查。
// 若要打印值：
// std::cout << "Age: " << age << std::endl;
// std::cout << "Name: " << name << std::endl;
```
</UniversalEditor>

## 控制流程语句对比

两种语言都支持 `if/else`、`for`、`while` 和 `switch` 等常见的控制流程结构，但语法上略有不同。

### If/Else 语句

<UniversalEditor title="If/Else 对比" compare={true}>
```javascript !! js
// JavaScript: If/Else
let temperature = 25;

if (temperature > 30) {
  console.log("天气很热！");
} else if (temperature > 20) {
  console.log("天气温暖。");
} else {
  console.log("天气很冷。");
}
```

```cpp !! cpp
// C++: If/Else
int temperature = 25;

if (temperature > 30) {
  // std::cout << "天气很热！" << std::endl;
} else if (temperature > 20) {
  // std::cout << "天气温暖。" << std::endl;
} else {
  // std::cout << "天气很冷。" << std::endl;
}
```
</UniversalEditor>

### For 循环

<UniversalEditor title="For 循环对比" compare={true}>
```javascript !! js
// JavaScript: For 循环
for (let i = 0; i < 5; i++) {
  console.log(i);
}

// For...of (用于可迭代对象)
let arr = [1, 2, 3];
for (let val of arr) {
  console.log(val);
}
```

```cpp !! cpp
// C++: For 循环
for (int i = 0; i < 5; i++) {
  // std::cout << i << std::endl;
}

// 范围基础 for 循环 (C++11 及更高版本)
std::vector<int> vec = {1, 2, 3};
for (int val : vec) {
  // std::cout << val << std::endl;
}
```
</UniversalEditor>

## 函数定义和调用

C++ 中的函数需要明确的返回类型和参数类型，这与 JavaScript 不同。

<UniversalEditor title="函数定义对比" compare={true}>
```javascript !! js
// JavaScript: 函数定义
function greet(name) {
  return `Hello, ${name}!`;
}

const add = (a, b) => a + b; // 箭头函数

console.log(greet("Bob"));
console.log(add(5, 3));
```

```cpp !! cpp
// C++: 函数定义
#include <string> // std::string 所需

std::string greet(std::string name) {
  return "Hello, " + name + "!";
}

int add(int a, int b) {
  return a + b;
}

// 在主函数中调用：
// std::cout << greet("Bob") << std::endl;
// std::cout << add(5, 3) << std::endl;
```
</UniversalEditor>

## 作用域和生命周期

两种语言都具有块作用域，但 C++ 变量的生命周期与其作用域的关联更为明确。

<UniversalEditor title="作用域和生命周期对比" compare={true}>
```javascript !! js
// JavaScript: 作用域
function example() {
  let x = 10;
  if (true) {
    let y = 20;
    console.log(x); // 10
    console.log(y); // 20
  }
  // console.log(y); // ReferenceError: y is not defined
}
example();
```

```cpp !! cpp
// C++: 作用域
#include <iostream>

void example() {
  int x = 10;
  if (true) {
    int y = 20;
    // std::cout << x << std::endl; // 10
    // std::cout << y << std::endl; // 20
  }
  // std::cout << y << std::endl; // 错误: 'y' 未在此作用域中声明
}
// 在 main 中调用 example()
```
</UniversalEditor>

## 基本数据类型对比

C++ 拥有一组更丰富的具有固定大小的基本数据类型，对内存有更多的控制。

| JavaScript 类型 | C++ 等效类型                                  |
| :-------------- | :------------------------------------------------- |
| `number`        | `int`, `float`, `double`, `long`, `short`, 等    |
| `string`        | `std::string`, `char[]`, `char*`                   |
| `boolean`       | `bool`                                             |
| `null`          | `nullptr` (C++11), `NULL` (C 样式)                |
| `undefined`     | 没有直接等效；通常由 `nullptr` 或特定逻辑表示 |
| `object`        | `class`, `struct`, `union`                         |
| `symbol`        | 没有直接等效                               |
| `bigint`        | `long long` (用于更大的整数), 外部函数库用于任意精度 |

## 运算符和表达式

大多数算术、比较和逻辑运算符是相似的，但 C++ 还有用于指针和内存管理的额外运算符。

<UniversalEditor title="运算符对比" compare={true}>
```javascript !! js
// JavaScript: 运算符
let a = 10, b = 3;
let sum = a + b; // 13
let isEqual = (a === b); // false (严格相等)
let isGreater = (a > b); // true
```

```cpp !! cpp
// C++: 运算符
int a = 10, b = 3;
int sum = a + b; // 13
bool isEqual = (a == b); // false (相等)
bool isGreater = (a > b); // true

// C++ 也有指针专用的运算符，例如 * (解引用) 和 & (取地址)
```
</UniversalEditor>

## 命名空间概念

C++ 使用命名空间来组织代码并防止命名冲突，类似于 JavaScript 中的模块或导入。

<UniversalEditor title="命名空间对比" compare={true}>
```javascript !! js
// JavaScript: 模块 (类似于命名空间)
// 文件: math.js
export const PI = 3.14;
export function add(a, b) { return a + b; }

// 文件: main.js
import { PI, add } from './math.js';
console.log(PI);
console.log(add(1, 2));
```

```cpp !! cpp
// C++: 命名空间
#include <iostream>

namespace Math {
  const double PI = 3.14;
  int add(int a, int b) { return a + b; }
}

// 在主函数或其他作用域中：
// std::cout << Math::PI << std::endl;
// std::cout << Math::add(1, 2) << std::endl;

// using 指令 (将所有名称引入当前作用域)
// using namespace Math;
// std::cout << PI << std::endl;
```
</UniversalEditor>

---

### 练习题：
1.  解释静态类型和动态类型之间的区别，并提供 JavaScript 和 C++ 的示例。
2.  编写一个 C++ 程序，接收用户年龄作为输入，并使用 `if/else if/else` 语句打印他们是未成年人、成年人还是老年人。
3.  命名空间在 C++ 编程中有何帮助？提供一个简单的示例。

### 项目构想：
*   用 C++ 创建一个简单的命令行程序，根据用户输入计算不同形状（圆形、矩形、三角形）的面积，展示函数使用和基本数据类型。